import apiClient from './interceptor';

/**
 * 应聘者简历信息接口
 */
interface ResumeInfo {
  name: string;          // 姓名
  email: string;         // 电子邮箱
  phone?: string;        // 联系电话（可选）
  resume: File;          // 简历文件
  planId?: number;       // 招聘计划ID（可选）
  deptId?: string;       // 应聘部门编号（可选）
  positionNumber?: string; // 应聘岗位编号（可选）
}

/**
 * 简历信息接口
 */
interface ResumeDetail {
  id: number;           // 应聘者ID
  name: string;         // 姓名
  email: string;        // 电子邮箱
  phone: string;        // 联系电话
  resume: Blob;         // 简历文件
  planId: number;       // 招聘计划ID
  deptId: string;       // 应聘部门编号
  positionNumber: string; // 应聘岗位编号
  createdAt: string;    // 创建时间
  updatedAt: string;    // 更新时间
}

/**
 * 应聘者查询参数接口
 */
interface IntervieweeQueryParams {
  page?: number;           // 当前页
  pageSize?: number;       // 页面大小
  planId?: number;         // 招聘计划id
  deptId?: string;         // 招聘部门编号
  positionNumber?: string; // 岗位编号
}

/**
 * 应聘者信息接口
 */
export interface Interviewee {
  id: number;              // 主键id
  name: string;            // 应聘人姓名
  email: string;           // 电子邮箱
  phone: string;           // 联系电话
  planId: number;          // 招聘计划id
  deptId: string;          // 应聘部门编号
  positionNumber: string;  // 应聘岗位编号
  interviewStatus: number; // 面试状态
  tryoutStartTime?: string;// 试用期开始时间
  tryoutEndTime?: string;  // 试用期结束时间
  tryoutDuration?: string; // 试用期时长
}

/**
 * 面试安排参数接口
 */
interface InterviewArrangement {
  interviewId: number;      // 面试id
  intervieweeIds: number[]; // 应聘者id列表
  subject: string;          // 邮件主题
  text: string;            // 邮件内容
}

/**
 * 修改面试状态参数接口
 */
interface UpdateInterviewStatus {
  intervieweeIds: number[];    // 应聘者id数组
  interviewStatus: number;     // 面试状态
}

/**
 * Offer申请参数接口
 */
interface OfferApplication {
  intervieweeId: number;  // 应聘者id
  instructions: string;   // 申请说明
}

/**
 * 取消面试安排参数接口
 */
interface CancelInterview {
  interviewId: number;      // 面试id
  intervieweeIds: number[]; // 应聘者id列表
  subject: string;          // 邮件主题
  text: string;            // 邮件内容
}

/**
 * 面试详情接口
 */
interface InterviewHistory {
  id: number;
  interviewId: number;
  intervieweeId: number;
  name: string;
  professionalSkills: number;
  communicationSkills: number;
  teamworkAbility: number;
  overallRating: number;
  comments: string | null;
  notes: string;
  createTime: string;
  updateTime: string;
  status: number;
  result: number;
}

interface InterviewHistoryResponse {
  total: number;
  row: InterviewHistory[];
}

/**
 * 上传应聘者简历
 * @description 上传应聘者的简历和相关信息
 * 
 * @param resumeInfo - 简历信息对象，包含姓名、邮箱、简历文件等
 * @returns Promise<{ code: number; msg: string; data: string | null }>
 * 
 * @example
 * ```typescript
 * const formData = new FormData();
 * formData.append('name', '张三');
 * formData.append('email', 'zhangsan@example.com');
 * formData.append('resume', file);
 * 
 * try {
 *   const response = await uploadResume({
 *     name: '张三',
 *     email: 'zhangsan@example.com',
 *     phone: '13800138000',
 *     resume: file,
 *     planId: 1,
 *     deptId: '001',
 *     positionNumber: 'P001'
 *   });
 *   
 *   if (response.code === 1) {
 *     // 上传成功
 *     console.log(response.msg);
 *   }
 * } catch (error) {
 *   console.error('上传简历失败:', error);
 * }
 * ```
 */
export const uploadResume = async (resumeInfo: ResumeInfo) => {
  try {
    // 创建 FormData 对象
    const formData = new FormData();
    
    // 添加必需字段
    formData.append('name', resumeInfo.name);
    formData.append('email', resumeInfo.email);
    formData.append('resume', resumeInfo.resume, resumeInfo.resume.name);
    
    // 添加可选字段
    if (resumeInfo.phone) {
      formData.append('phone', resumeInfo.phone);
    }
    if (resumeInfo.planId) {
      formData.append('planId', resumeInfo.planId.toString());
    }
    if (resumeInfo.deptId) {
      formData.append('deptId', resumeInfo.deptId);
    }
    if (resumeInfo.positionNumber) {
      formData.append('positionNumber', resumeInfo.positionNumber);
    }

    // 打印 FormData 内容
    console.log('FormData 内容:');
    const entries = Array.from(formData.entries());
    for (const [key, value] of entries) {
      if (value instanceof File) {
        console.log(key, ':', {
          name: value.name,
          type: value.type,
          size: value.size
        });
      } else {
        console.log(key, ':', value);
      }
    }

    // 修改请求配置
    const response = await apiClient.post('/interview/interviewee/resume/add', formData, {
      headers: {
        'Content-Type': 'multipart/form-data; boundary=' + Math.random().toString().substr(2),
        'Accept': 'application/json',
      },
      transformRequest: [(data) => data], // 阻止 axios 转换请求数据
    });

    return response.data;
  } catch (error) {
    console.error('上传简历失败:', error);
    throw error;
  }
};

/**
 * 查询应聘者简历
 * @description 根据应聘者ID查询简历信息
 * 
 * @param id - 应聘者ID
 * @returns Promise<{ code: number; msg: string; data: ResumeDetail | null }>
 * 
 * @example
 * ```typescript
 * try {
 *   const response = await getResumeById(1);
 *   if (response.code === 1) {
 *     const resumeInfo = response.data;
 *     // 处理简历信息
 *     console.log(resumeInfo);
 *   }
 * } catch (error) {
 *   console.error('获取简历失败:', error);
 * }
 * ```
 */
export const getResumeById = async (id: number) => {
  try {
    // 打印请求参数
    console.log('查询简历请求:', { id });

    const response = await apiClient.get('/interview/interviewee/resume', {
      params: { id }
    });

    // 打印响应结果
    console.log('查询简历响应:', response.data);

    return response.data;
  } catch (error) {
    console.error('查询简历失败:', error);
    throw error;
  }
};

/**
 * 查询应聘者列表
 * @description 根据条件查询应聘者列表，支持分页和筛选
 * 
 * @param params - 查询参数，包含页码、每页大小、筛选条件等
 * @returns Promise<{ code: number; msg: string; data: Interviewee[] | null }>
 * 
 * @example
 * ```typescript
 * try {
 *   const response = await getInterviewees({
 *     page: 1,
 *     pageSize: 10,
 *     planId: 1,
 *     deptId: '001',
 *     positionNumber: 'P001'
 *   });
 *   
 *   if (response.code === 1) {
 *     const interviewees = response.data;
 *     // 处理应聘者列表
 *     console.log(interviewees);
 *   }
 * } catch (error) {
 *   console.error('获取应聘者列表失败:', error);
 * }
 * ```
 */
export const getInterviewees = async (params?: IntervieweeQueryParams) => {
  try {
    // 打印请求参数
    console.log('查询应聘者列表请求:', params);

    const response = await apiClient.get('/interview/interviewee', {
      params: {
        page: params?.page || 1,
        pageSize: params?.pageSize || 10,
        planId: params?.planId,
        deptId: params?.deptId,
        positionNumber: params?.positionNumber
      }
    });

    // 打印响应结果
    console.log('查询应聘者列表响应:', response.data);

    return response.data;
  } catch (error) {
    console.error('查询应聘者列表失败:', error);
    throw error;
  }
};

/**
 * 面试状态枚举
 */
export enum InterviewStatus {
  Candidate = 0,      // 候选人（初始状态）
  Scheduled = 1,      // 已安排面试
  Interviewing = 2,    // 面试中
  PendingOffer = 3,    // 待发offer
  OfferSent = 4,        // 已发offer
  OfferAccepted = 5,   // 已接受offer
  Onboard = 6,          // 已入职
  Rejected = 7,        // 已拒绝
  Blacklist = 8,        // 黑名单
  FormalEmployee = 9,   // 正式员工
  Resigned = 10        // 已离职
}

/**
 * 为应聘者安排面试并发送邮件
 * @description 安排面试并向应聘者发送面试邀请邮件
 * 
 * @param arrangement - 面试安排信息，包含面试ID、应聘者ID列表、邮件主题和内容
 * @returns Promise<{ code: number; msg: string; data: null }>
 * 
 * @example
 * ```typescript
 * try {
 *   const response = await arrangeInterview({
 *     interviewId: 48,
 *     intervieweeIds: [31, 80],
 *     subject: '面试邀请：前端开发工程师',
 *     text: '尊敬的候选人：\n\n诚邀您参加我们的面试...'
 *   });
 *   
 *   if (response.code === 1) {
 *     message.success('面试安排成功，邮件已发送');
 *   }
 * } catch (error) {
 *   console.error('安排面试失败:', error);
 * }
 * ```
 */
export const arrangeInterview = async (arrangement: InterviewArrangement) => {
  try {
    // 打印请求参数
    console.log('安排面试请求:', {
      interviewId: arrangement.interviewId,
      intervieweeCount: arrangement.intervieweeIds.length,
      subject: arrangement.subject
    });

    const response = await apiClient.post('/interview/interviewee', arrangement, {
      headers: {
        'Content-Type': 'application/json'
      }
    });

    // 打印响应结果
    console.log('安排面试响应:', response.data);

    return response.data;
  } catch (error) {
    console.error('安排面试失败:', error);
    throw error;
  }
};

/**
 * 生成默认的面试邀请邮件内容
 * @param interviewInfo - 面试相关信息
 * @returns { subject: string; text: string } 返回邮件主题和内容
 */
export const generateInterviewEmail = (interviewInfo: {
  positionName: string;
  date: string;
  time: string;
  location: string;
  contactPerson: string;
  contactPhone: string;
}) => {
  const subject = `面试邀请：${interviewInfo.positionName}`;
  
  const text = `
尊敬的候选人：

您好！

感谢您对我们公司的关注和信任。经过初步筛选，我们诚挚地邀请您参加面试。

面试详情：
- 职位：${interviewInfo.positionName}
- 日期：${interviewInfo.date}
- 时间：${interviewInfo.time}
- 地点：${interviewInfo.location}

请提前15分钟到达面试地点。如果您需要调整面试时间或有任何疑问，请联系：
${interviewInfo.contactPerson}（${interviewInfo.contactPhone}）

请回复此邮件确认是否参加面试。

期待与您的见面！

祝好，
桂林信息科技学院人事处
`.trim();

  return { subject, text };
};

/**
 * 修改应聘者面试状态
 * @description 更新应聘者的面试状态
 * 
 * @param params - 更新参数，包含应聘者ID和新的面试状态
 * @returns Promise<{ code: number; msg: string; data: null }>
 * 
 * @example
 * ```typescript
 * try {
 *   const response = await updateIntervieweeStatus({
 *     intervieweeIds: [46],
 *     interviewStatus: InterviewStatus.Interviewing
 *   });
 *   
 *   if (response.code === 1) {
 *     message.success('面试状态更新成功');
 *   }
 * } catch (error) {
 *   console.error('更新面试状态失败:', error);
 * }
 * ```
 */
export const updateIntervieweeStatus = async (params: UpdateInterviewStatus) => {
  try {
    const response = await apiClient.put('/interview/interviewee', params);
    return response.data;
  } catch (error) {
    console.error('更新面试状态失败:', error);
    throw error;
  }
};

/**
 * 获取面试状态显示文本
 */
export const getInterviewStatusText = (status: number): string => {
  const statusMap = {
    [InterviewStatus.Candidate]: '候选人',
    [InterviewStatus.Scheduled]: '已安排面试',
    [InterviewStatus.Interviewing]: '面试中',
    [InterviewStatus.PendingOffer]: '待发offer',
    [InterviewStatus.OfferSent]: '已发offer',
    [InterviewStatus.OfferAccepted]: '已接受offer',
    [InterviewStatus.Onboard]: '已入职',
    [InterviewStatus.Rejected]: '已拒绝',
    [InterviewStatus.Blacklist]: '黑名单',
    [InterviewStatus.FormalEmployee]: '正式员工',
    [InterviewStatus.Resigned]: '已离职'
  };
  return statusMap[status] || '未知状态';
};

/**
 * 删除应聘者信息
 * @description 删除指定的应聘者信息，并发送邮件通知
 * 
 * @param intervieweeIds - 要删除的应聘者ID数组
 * @returns Promise<{ code: number; msg: string; data: null }>
 * 
 * @example
 * ```typescript
 * try {
 *   const response = await deleteInterviewees([1, 2, 3]);
 *   
 *   if (response.code === 1) {
 *     message.success('应聘者信息删除成功');
 *   }
 * } catch (error) {
 *   console.error('删除应聘者信息失败:', error);
 * }
 * ```
 */
export const deleteInterviewees = async (intervieweeIds: number[]) => {
  try {
    if (!intervieweeIds.length) {
      throw new Error('请选择要删除的应聘者');
    }

    // 打印请求参数
    console.log('删除应聘者请求:', {
      intervieweeIds,
      count: intervieweeIds.length
    });

    const response = await apiClient.delete(`/interview/interviewee/${intervieweeIds.join(',')}`);

    // 打印响应结果
    console.log('删除应聘者响应:', response.data);

    return response.data;
  } catch (error) {
    console.error('删除应聘者失败:', error);
    throw error;
  }
};

/**
 * 批量操作应聘者信息
 * @description 批量删除或更新应聘者状态
 * 
 * @param action - 操作类型，'delete' 或 'updateStatus'
 * @param ids - 要操作的应聘者ID数组
 * @param status - 新的面试状态（仅在 updateStatus 时需要）
 * @returns Promise<void>
 * 
 * @example
 * ```typescript
 * // 批量删除
 * await batchIntervieweeOperation('delete', [1, 2, 3]);
 * 
 * // 批量更新状态
 * await batchIntervieweeOperation('updateStatus', [1, 2, 3], InterviewStatus.Rejected);
 * ```
 */
export const batchIntervieweeOperation = async (
  action: 'delete' | 'updateStatus',
  ids: number[],
  status?: number
) => {
  try {
    if (!ids.length) {
      throw new Error('请选择要操作的应聘者');
    }

    let response;
    if (action === 'delete') {
      response = await deleteInterviewees(ids);
    } else if (action === 'updateStatus' && typeof status === 'number') {
      const updatePromises = ids.map(id => 
        updateIntervieweeStatus({
          intervieweeIds: [id],
          interviewStatus: status
        })
      );
      response = await Promise.all(updatePromises);
    }

    return response;
  } catch (error) {
    console.error('批量操作失败:', error);
    throw error;
  }
};

/**
 * 为应聘者申请offer
 * @description 为指定的应聘者申请offer
 * 
 * @param params - 申请参数，包含应聘者ID和申请说明
 * @returns Promise<{ code: number; msg: string; data: null }>
 * 
 * @example
 * ```typescript
 * try {
 *   const response = await applyOffer({
 *     intervieweeId: 39,
 *     instructions: '该候选人各方面表现优秀，建议发放offer'
 *   });
 *   
 *   if (response.code === 1) {
 *     message.success('offer申请提交成功');
 *   }
 * } catch (error) {
 *   console.error('申请offer失败:', error);
 * }
 * ```
 */
export const applyOffer = async (params: OfferApplication) => {
  try {
    if (!params.instructions.trim()) {
      throw new Error('请填写申请说明');
    }

    // 打印请求参数
    console.log('申请offer请求:', {
      intervieweeId: params.intervieweeId,
      instructions: params.instructions
    });

    const response = await apiClient.post('/interview/interviewee/offer', params, {
      headers: {
        'Content-Type': 'application/json'
      }
    });

    // 打印响应结果
    console.log('申请offer响应:', response.data);

    return response.data;
  } catch (error) {
    console.error('申请offer失败:', error);
    throw error;
  }
};

/**
 * 生成默认的offer申请说明
 * @param info - 应聘者相关信息
 * @returns string 申请说明文本
 */
export const generateOfferInstructions = (info: {
  name: string;
  position: string;
  department: string;
  interviewScore?: number;
  specialNote?: string;
}) => {
  const text = `
申请为 ${info.department} - ${info.position} 岗位的应聘者 ${info.name} 发放offer。

面试评价：
${info.interviewScore ? `- 面试综合得分：${info.interviewScore}分` : ''}
- 候选人整体表现良好，符合岗位要求
${info.specialNote ? `- 特别说明：${info.specialNote}` : ''}

建议发放offer。
`.trim();

  return text;
};

/**
 * 取消应聘者的面试安排
 * @description 取消已安排的面试并发送通知邮件
 * 
 * @param params - 取消面试参数，包含面试ID、应聘者ID列表、邮件主题和内容
 * @returns Promise<{ code: number; msg: string; data: null }>
 * 
 * @example
 * ```typescript
 * try {
 *   const response = await cancelInterview({
 *     interviewId: 48,
 *     intervieweeIds: [31, 80],
 *     subject: '面试取消通知',
 *     text: '很抱歉，因特殊原因需要取消本次面试...'
 *   });
 *   
 *   if (response.code === 1) {
 *     message.success('面试已取消，通知邮件已发送');
 *   }
 * } catch (error) {
 *   console.error('取消面试失败:', error);
 * }
 * ```
 */
export const cancelInterview = async (params: CancelInterview) => {
  try {
    if (!params.intervieweeIds.length) {
      throw new Error('请选择要取消面试的应聘者');
    }

    // 打印请求参数
    console.log('取消面试请求:', {
      interviewId: params.interviewId,
      intervieweeCount: params.intervieweeIds.length,
      subject: params.subject
    });

    const response = await apiClient.post('/interview/interviewee/cancel', params, {
      headers: {
        'Content-Type': 'application/json'
      }
    });

    // 打印响应结果
    console.log('取消面试响应:', response.data);

    return response.data;
  } catch (error) {
    console.error('取消面试失败:', error);
    throw error;
  }
};

/**
 * 生成默认的面试取消邮件内容
 * @param info - 面试相关信息
 * @returns { subject: string; text: string } 返回邮件主题和内容
 */
export const generateCancelInterviewEmail = (info: {
  positionName: string;
  originalDate: string;
  originalTime: string;
  reason?: string;
  contactPerson: string;
  contactPhone: string;
  willReschedule?: boolean;
}) => {
  const subject = `面试取消通知：${info.positionName}`;
  
  const text = `
尊敬的候选人：

您好！

很抱歉地通知您，原定于 ${info.originalDate} ${info.originalTime} 的${info.positionName}岗位面试需要取消。

${info.reason ? `取消原因：${info.reason}` : ''}

${info.willReschedule ? 
  '我们会尽快重新安排面试时间，请保持手机畅通。' : 
  '如果后续有合适的机会，我们会再次与您联系。'
}

如有任何疑问，请联系：
${info.contactPerson}（${info.contactPhone}）

对由此带来的不便，我们深表歉意。

祝好，
桂林信息科技学院人事处
`.trim();

  return { subject, text };
};

/**
 * 获取应聘者的面试历史记录
 * @description 获取指定应聘者的所有面试评价详情
 * 
 * @param intervieweeId - 应聘者ID
 * @param page - 当前页码，默认1
 * @param pageSize - 每页条数，默认10
 * @returns Promise<{ code: number; msg: string; data: InterviewHistoryResponse }>
 * 
 * @example
 * ```typescript
 * try {
 *   const response = await getIntervieweeHistory(1);
 *   if (response.code === 1) {
 *     const { total, row } = response.data;
 *     console.log(`共有 ${total} 条面试记录`);
 *     console.log('面试历史:', row);
 *   }
 * } catch (error) {
 *   console.error('获取面试历史失败:', error);
 * }
 * ```
 */
export const getIntervieweeHistory = async (
  intervieweeId: number,
  page: number = 1,
  pageSize: number = 10
) => {
  try {
    // 打印请求参数
    console.log('获取面试历史请求:', { intervieweeId, page, pageSize });

    const response = await apiClient.get('/interview/situation', {
      params: {
        intervieweeId,
        page,
        pageSize
      }
    });

    // 打印响应结果
    console.log('获取面试历史响应:', response.data);

    return response.data;
  } catch (error) {
    console.error('获取面试历史失败:', error);
    throw error;
  }
};
